// function findOriginalLength(stickLengths) {  
//     // 如果数组为空，则无法确定原始长度  
//     if (stickLengths.length === 0) {  
//       return null;  
//     }  
    
//     // 初始化最大公约数为第一个木棍的长度  
//     let gcd = stickLengths[0];  
    
//     // 遍历所有木棍长度，计算最大公约数  
//     for (let i = 1; i < stickLengths.length; i++) {  
//       gcd = euclideanGcd(gcd, stickLengths[i]);  
//     }  
    
//     return gcd;  
//   }  
    
//   // 欧几里得算法计算两个数的最大公约数  
//   function euclideanGcd(a, b) {  
//     while (b !== 0) {  
//       const temp = b;  
//       b = a % b;  
//       a = temp;  
//     }  
//     return a;  
//   }  
    
//   // 示例木棍长度数组  
//   const stickLengths = [20, 40, 60, 80, 100]; // 假设这是乔治砍断后得到的木棍长度  
    
//   // 调用函数并打印结果  
//   const originalLength = findOriginalLength(stickLengths);  
//   console.log(`原始木棒的可能最小长度是: ${originalLength}`);


//   var isAnagram = function(s, t) {
//     if(s.length !== t.length) return false;
//     let map = new Map();

//     for(let i = 0; i< s.length; i++){
//         map.set(s[i], map.has(s[i]) ? map.get(s[i]) + 1 : 1)
//         map.set(t[i], map.has(t[i]) ? map.get(t[i]) - 1 : -1)
//     }
//     console.log(map, Array.from(map))
//     return Array.from(map).every(([k,v]) => v === 0)
// };

// isAnagram("anagram","nagaram" )

// var longestPalindrome = function(s) {
//   let map = new Map();
//   let count = 0;
//   for(let i = 0; i< s.length; i++){
//       if(map.has(s[i])){
//           count += 2
//           map.delete(s[i])
//       } else {
//         map.set(s[i], true)
//       }

//   }
//   console.log(map)
//   return Array.from(map).length > 0 ? count + 1 : count

// };
// longestPalindrome("abccccdd")


// var sortColors = function(nums) {
//   let index = 0;
//   while(index < nums.length){
//       if(nums[index] === 0){
//           let target = nums.splice(index, 1)
//           nums.unshift(target[0])
//       } else if(nums[index] === 2) {
//           let target = nums.splice(index, 1)
//           nums.push(target[0])
//           index--
//       }
//       index++
//   }
//   return nums
// };
// console.log(sortColors([2,0,2,1,1,0]))



function pruneTreeToTargetNodes(tree, targetKeys) {
    // 创建一个Set来存储需要保留的节点的key
    const keysToKeep = new Set(targetKeys);
    
    // 创建一个Set来存储已经访问过的节点的key，以避免重复处理
    const visitedKeys = new Set();
    
    // 定义一个递归函数来遍历树并修剪不必要的节点
    function traverse(node, parentNode = null) {
      // 如果当前节点已经被访问过，则直接返回null（表示该节点应该被修剪掉）
      if (visitedKeys.has(node.key)) {
        return null;
      }
      
      // 标记当前节点为已访问
      visitedKeys.add(node.key);
      
      // 检查当前节点的key是否在需要保留的key集合中
      if (keysToKeep.has(node.key)) {
        // 如果在，则保留当前节点，并递归地保留其子节点（如果有的话）
        if (node.children) {
          node.children = node.children.map(child => traverse(child, node));
          // 过滤掉被修剪掉的子节点（即返回值为null的节点）
          node.children = node.children.filter(child => child !== null);
        }
        return node; // 返回保留的节点
      } else {
        // 如果不在，则检查当前节点是否有父节点，并且父节点的key是否在需要保留的key集合中
        if (parentNode && keysToKeep.has(parentNode.key)) {
          // 如果有父节点且父节点需要保留，则只保留当前节点（作为叶子节点，移除其子节点）
          return { ...node, children: [] }; // 返回只包含当前节点的对象（不含子节点）
        } else {
          // 如果没有父节点需要保留，或者当前节点就是根节点但不在需要保留的集合中，则返回null（表示该节点及其子树应该被修剪掉）
          return null;
        }
      }
    }
    
    // 对树的每个根节点调用递归函数，并传入null作为父节点（因为根节点没有父节点）
    const prunedTree = tree.map(root => traverse(root)).filter(root => root !== null);
    
    return prunedTree; // 返回修剪后的树
  }
  
  // 示例树结构
  const tree = [
    {
      key: '1',
      label: 'Node 1',
      children: [
        {
          key: '1-1',
          label: 'Node 1-1',
          children: []
        },
        {
          key: '1-2',
          label: 'Node 1-2',
          children: [
            {
              key: '1-2-1',
              label: 'Node 1-2-1',
              children: []
            }
          ]
        }
      ]
    },
    {
      key: '2',
      label: 'Node 2',
      children: [
        {
          key: '2-1',
          label: 'Node 2-1',
          children: []
        },
        {
          key: '2-2',
          label: 'Node 2-2',
          children: []
        }
      ]
    }
  ];
  
  // 要保留的节点key列表
  const targetKeys = ['1-2-1', '2-1'];
  
  // 调用函数并打印结果
  const prunedTree = pruneTreeToTargetNodes(tree, targetKeys);
  console.log(JSON.stringify(prunedTree, null, 2));
  function mergeArrays(arr1, arr2) {
    return [...arr1, ...arr2];
  }

  // 示例数组
  const array1 = [1, 2, 3];
  const array2 = [4, 5, 6];

  // 调用函数并打印结果
  const mergedArray = mergeArrays(array1, array2);
  console.log(mergedArray); // 输出: [1, 2, 3, 4, 5, 6]